package com.note.app.controller;

import com.note.app.annotation.LogRecord;
import com.note.app.dto.ai.AICreateNoteRequestDTO;
import com.note.app.dto.ai.AIEditNoteRequestDTO;
import com.note.app.dto.ai.AIChatRequestDTO;
import com.note.app.dto.ai.AIResponseDTO;
import com.note.app.service.AIService;
import com.note.common.context.UserContext;
import com.note.common.domain.AIConversation;
import com.note.common.vo.ResponseVo;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

/**
 * AI功能控制器
 */
@Slf4j
@RestController
@RequestMapping("/ai")
@RequiredArgsConstructor
@Tag(name = "AI功能", description = "AI辅助写作相关接口")
public class AIController {

    private final AIService aiService;

    /**
     * AI辅助创建笔记
     * 
     * @param request 创建笔记请求
     * @return AI生成的内容
     */
    @PostMapping("/create")
    @Operation(summary = "AI辅助创建笔记", description = "根据用户提示创建笔记内容")
    @LogRecord(description = "AI辅助创建笔记", module = "AI功能", operationType = LogRecord.OperationType.CREATE)
    public ResponseVo<AIResponseDTO> createNote(@RequestBody AICreateNoteRequestDTO request) {
        try {
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            log.info("开始AI辅助创建笔记 - 用户ID: {}, 模式: {}, 提示词: {}", userId, request.getMode(), request.getPrompt());
            
            // 验证请求参数
            if (request.getPrompt() == null || request.getPrompt().trim().isEmpty()) {
                log.warn("AI辅助创建笔记 - 提示词为空");
                return ResponseVo.error("提示词不能为空");
            }
            
            if (request.getMode() == null || request.getMode().trim().isEmpty()) {
                log.warn("AI辅助创建笔记 - 模式为空");
                return ResponseVo.error("AI模式不能为空");
            }
            
            log.info("调用AI服务生成笔记内容 - 同步等待...");
            // 调用服务 - 这是同步调用，会等待API完成
            AIResponseDTO response = aiService.generateNoteContent(userId, request);
            
            if (response == null) {
                log.error("AI辅助创建笔记 - 服务返回空结果");
                return ResponseVo.error("AI生成内容失败，请稍后重试");
            }
            
            log.info("AI辅助创建笔记成功 - 用户ID: {}, 会话ID: {}", userId, response.getConversationId());
            return ResponseVo.success(response);
        } catch (Exception e) {
            log.error("AI辅助创建笔记异常", e);
            return ResponseVo.error("AI生成内容异常: " + e.getMessage());
        }
    }
    
    /**
     * AI辅助编辑笔记
     * 
     * @param request 编辑笔记请求
     * @return AI生成的内容
     */
    @PostMapping("/edit")
    @Operation(summary = "AI辅助编辑笔记", description = "根据现有笔记内容和用户提示进行AI增强")
    @LogRecord(description = "AI辅助编辑笔记", module = "AI功能", operationType = LogRecord.OperationType.UPDATE)
    public ResponseVo<AIResponseDTO> editNote(@RequestBody AIEditNoteRequestDTO request) {
        try {
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            log.info("开始AI辅助编辑笔记 - 用户ID: {}, 模式: {}, 笔记ID: {}", userId, request.getMode(), request.getNoteId());
            
            // 验证请求参数
            if (request.getMode() == null || request.getMode().trim().isEmpty()) {
                log.warn("AI辅助编辑笔记 - 模式为空");
                return ResponseVo.error("AI模式不能为空");
            }
            
            if (request.getNoteId() == null && !request.getIncludeContent()) {
                log.warn("AI辅助编辑笔记 - 笔记ID为空且未包含内容");
                return ResponseVo.error("必须提供笔记ID或笔记内容");
            }
            
            if (request.getIncludeContent() && (request.getContent() == null || request.getContent().trim().isEmpty())) {
                log.warn("AI辅助编辑笔记 - 声明包含内容但内容为空");
                return ResponseVo.error("声明包含内容但内容为空");
            }
            
            log.info("调用AI服务增强笔记内容 - 同步等待...");
            // 调用服务 - 这是同步调用，会等待API完成
            AIResponseDTO response = aiService.enhanceNoteContent(userId, request);
            
            if (response == null) {
                log.error("AI辅助编辑笔记 - 服务返回空结果");
                return ResponseVo.error("AI增强内容失败，请稍后重试");
            }
            
            log.info("AI辅助编辑笔记成功 - 用户ID: {}, 笔记ID: {}, 会话ID: {}", 
                userId, request.getNoteId(), response.getConversationId());
            return ResponseVo.success(response);
        } catch (Exception e) {
            log.error("AI辅助编辑笔记异常", e);
            return ResponseVo.error("AI增强内容异常: " + e.getMessage());
        }
    }
    
    /**
     * 获取用户AI对话历史
     * 
     * @param page 页码，从0开始
     * @param size 每页大小
     * @return 对话历史列表
     */
    @GetMapping("/history")
    @Operation(summary = "获取AI对话历史", description = "获取当前用户的AI对话历史记录")
    @LogRecord(description = "获取AI对话历史", module = "AI功能", operationType = LogRecord.OperationType.QUERY)
    public ResponseVo<Object> getHistory(
            @RequestParam(defaultValue = "0") Integer page,
            @RequestParam(defaultValue = "10") Integer size) {
        // 获取当前用户ID
        Long userId = UserContext.getUserId();
        log.info("获取AI对话历史 - 用户ID: {}, 页码: {}, 大小: {}", userId, page, size);
        
        // 调用服务获取历史记录
        Object result = aiService.getUserConversations(userId, page, size);
        
        return ResponseVo.success(result);
    }
    
    /**
     * 获取AI对话详情
     * 
     * @param conversationId 对话ID
     * @return 对话详情
     */
    @GetMapping("/conversation/{conversationId}")
    @Operation(summary = "获取AI对话详情", description = "获取指定ID的AI对话详情")
    @LogRecord(description = "获取AI对话详情", module = "AI功能", operationType = LogRecord.OperationType.QUERY)
    public ResponseVo<AIConversation> getConversation(@PathVariable Long conversationId) {
        // 获取当前用户ID
        Long userId = UserContext.getUserId();
        log.info("获取AI对话详情 - 用户ID: {}, 对话ID: {}", userId, conversationId);
        
        // 调用服务获取对话详情
        AIConversation conversation = aiService.getConversationById(conversationId);
        
        // 检查权限
        if (conversation == null || !conversation.getUserId().equals(userId)) {
            return ResponseVo.error("无权访问该对话记录");
        }
        
        return ResponseVo.success(conversation);
    }
    
    /**
     * 删除AI对话历史
     * 
     * @param conversationId 对话ID
     * @return 是否成功
     */
    @DeleteMapping("/conversation/{conversationId}")
    @Operation(summary = "删除AI对话历史", description = "删除指定ID的AI对话历史")
    @LogRecord(description = "删除AI对话历史", module = "AI功能", operationType = LogRecord.OperationType.DELETE)
    public ResponseVo<Boolean> deleteConversation(@PathVariable Long conversationId) {
        // 获取当前用户ID
        Long userId = UserContext.getUserId();
        log.info("删除AI对话历史 - 用户ID: {}, 对话ID: {}", userId, conversationId);
        
        // 调用服务删除对话历史
        boolean success = aiService.deleteConversation(userId, conversationId);
        
        return success ? ResponseVo.success(true) : ResponseVo.error("删除失败");
    }

    /**
     * AI聊天功能
     * 
     * @param request 聊天请求
     * @return AI生成的回复
     */
    @PostMapping("/chat")
    @Operation(summary = "AI聊天", description = "与AI进行对话交流")
    @LogRecord(description = "AI聊天", module = "AI功能", operationType = LogRecord.OperationType.OTHER)
    public ResponseVo<AIResponseDTO> chatWithAI(@RequestBody AIChatRequestDTO request) {
        try {
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            log.info("开始AI聊天 - 用户ID: {}, 消息条数: {}", userId, 
                request.getMessages() != null ? request.getMessages().size() : 0);
            
            // 验证请求参数
            if (request.getMessages() == null || request.getMessages().isEmpty()) {
                log.warn("AI聊天 - 消息为空");
                return ResponseVo.error("消息不能为空");
            }
            
            log.info("调用AI服务进行聊天 - 同步等待...");
            // 调用服务 - 这是同步调用，会等待API完成
            AIResponseDTO response = aiService.chatWithAI(userId, request);
            
            if (response == null) {
                log.error("AI聊天 - 服务返回空结果");
                return ResponseVo.error("AI聊天失败，请稍后重试");
            }
            
            log.info("AI聊天成功 - 用户ID: {}, 会话ID: {}", userId, response.getConversationId());
            return ResponseVo.success(response);
        } catch (Exception e) {
            log.error("AI聊天异常", e);
            return ResponseVo.error("AI聊天异常: " + e.getMessage());
        }
    }
} 